11 research outputs found
Defining Recursive Predicates in Graph Orders
We study the first order theory of structures over graphs i.e. structures of
the form () where is the set of all
(isomorphism types of) finite undirected graphs and some vocabulary. We
define the notion of a recursive predicate over graphs using Turing Machine
recognizable string encodings of graphs. We also define the notion of an
arithmetical relation over graphs using a total order on the set
such that () is isomorphic to
().
We introduce the notion of a \textit{capable} structure over graphs, which is
one satisfying the conditions : (1) definability of arithmetic, (2)
definability of cardinality of a graph, and (3) definability of two particular
graph predicates related to vertex labellings of graphs. We then show any
capable structure can define every arithmetical predicate over graphs. As a
corollary, any capable structure also defines every recursive graph relation.
We identify capable structures which are expansions of graph orders, which are
structures of the form () where is a partial order. We
show that the subgraph order i.e. (), induced subgraph
order with one constant i.e. () and an expansion
of the minor order for counting edges i.e. ()
are capable structures. In the course of the proof, we show the definability of
several natural graph theoretic predicates in the subgraph order which may be
of independent interest. We discuss the implications of our results and
connections to Descriptive Complexity
Regular Separability and Intersection Emptiness Are Independent Problems
The problem of regular separability asks, given two languages K and L, whether there exists a regular language S that includes K and is disjoint from L. This problem becomes interesting when the input languages K and L are drawn from language classes beyond the regular languages. For such classes, a mild and useful assumption is that they are full trios, i.e. closed under rational transductions.
All the results on regular separability for full trios obtained so far exhibited a noteworthy correspondence with the intersection emptiness problem: In each case, regular separability is decidable if and only if intersection emptiness is decidable. This raises the question whether for full trios, regular separability can be reduced to intersection emptiness or vice-versa.
We present counterexamples showing that neither of the two problems can be reduced to the other. More specifically, we describe full trios C_1, D_1, C_2, D_2 such that (i) intersection emptiness is decidable for C_1 and D_1, but regular separability is undecidable for C_1 and D_1 and (ii) regular separability is decidable for C_2 and D_2, but intersection emptiness is undecidable for C_2 and D_2
General Decidability Results for Asynchronous Shared-Memory Programs: Higher-Order and Beyond
The model of asynchronous programming arises in many contexts, from low-level
systems software to high-level web programming. We take a language-theoretic
perspective and show general decidability and undecidability results for
asynchronous programs that capture all known results as well as show
decidability of new and important classes. As a main consequence, we show
decidability of safety, termination and boundedness verification for
higher-order asynchronous programs -- such as OCaml programs using Lwt -- and
undecidability of liveness verification already for order-2 asynchronous
programs. We show that under mild assumptions, surprisingly, safety and
termination verification of asynchronous programs with handlers from a language
class are decidable iff emptiness is decidable for the underlying language
class. Moreover, we show that configuration reachability and liveness (fair
termination) verification are equivalent, and decidability of these problems
implies decidability of the well-known "equal-letters" problem on languages.
Our results close the decidability frontier for asynchronous programs
The Complexity of Bounded Context Switching with Dynamic Thread Creation
Dynamic networks of concurrent pushdown systems (DCPS) are a theoretical
model for multi-threaded recursive programs with shared global state and
dynamical creation of threads. The (global) state reachability problem for DCPS
is undecidable in general, but Atig et al. (2009) showed that it becomes
decidable, and is in 2EXPSPACE, when each thread is restricted to a fixed
number of context switches. The best known lower bound for the problem is
EXPSPACE-hard and this lower bound follows already when each thread is a
finite-state machine and runs atomically to completion (i.e., does not switch
contexts). In this paper, we close the gap by showing that state reachability
is 2EXPSPACE-hard already with only one context switch. Interestingly, state
reachability analysis is in EXPSPACE both for pushdown threads without context
switches as well as for finite-state threads with arbitrary context switches.
Thus, recursive threads together with a single context switch provide an
exponential advantage.
Our proof techniques are of independent interest for 2EXPSPACE-hardness
results. We introduce transducer-defined Petri nets, a succinct representation
for Petri nets, and show coverability is 2EXPSPACE-hard for this model. To show
2EXPSPACE-hardness, we present a modified version of Lipton's simulation of
counter machines by Petri nets, where the net programs can make explicit
recursive procedure calls up to a bounded depth
Existential Definability over the Subword Ordering
We study first-order logic (FO) over the structure consisting of finite words
over some alphabet , together with the (non-contiguous) subword ordering. In
terms of decidability of quantifier alternation fragments, this logic is
well-understood: If every word is available as a constant, then even the
(i.e., existential) fragment is undecidable, already for binary
alphabets . However, up to now, little is known about the expressiveness of
the quantifier alternation fragments: For example, the undecidability proof for
the existential fragment relies on Diophantine equations and only shows that
recursively enumerable languages over a singleton alphabet (and some auxiliary
predicates) are definable. We show that if , then a relation is
definable in the existential fragment over with constants if and only if it
is recursively enumerable. This implies characterizations for all fragments
: If , then a relation is definable in if and
only if it belongs to the -th level of the arithmetical hierarchy. In
addition, our result yields an analogous complete description of the
-fragments for of the pure logic, where the words of
are not available as constants
Existential Definability over the Subword Ordering
We study first-order logic (FO) over the structure consisting of finite words over some alphabet A, together with the (non-contiguous) subword ordering. In terms of decidability of quantifier alternation fragments, this logic is well-understood: If every word is available as a constant, then even the ?? (i.e., existential) fragment is undecidable, already for binary alphabets A.
However, up to now, little is known about the expressiveness of the quantifier alternation fragments: For example, the undecidability proof for the existential fragment relies on Diophantine equations and only shows that recursively enumerable languages over a singleton alphabet (and some auxiliary predicates) are definable.
We show that if |A| ? 3, then a relation is definable in the existential fragment over A with constants if and only if it is recursively enumerable. This implies characterizations for all fragments ?_i: If |A| ? 3, then a relation is definable in ?_i if and only if it belongs to the i-th level of the arithmetical hierarchy. In addition, our result yields an analogous complete description of the ?_i-fragments for i ? 2 of the pure logic, where the words of A^* are not available as constants
Reachability in Continuous Pushdown VASS
Pushdown Vector Addition Systems with States (PVASS) consist of finitely many
control states, a pushdown stack, and a set of counters that can be incremented
and decremented, but not tested for zero. Whether the reachability problem is
decidable for PVASS is a long-standing open problem.
We consider continuous PVASS, which are PVASS with a continuous semantics.
This means, the counter values are rational numbers and whenever a vector is
added to the current counter values, this vector is first scaled with an
arbitrarily chosen rational factor between zero and one. We show that
reachability in continuous PVASS is NEXPTIME-complete. Our result is unusually
robust: Reachability can be decided in NEXPTIME even if all numbers are
specified in binary. On the other hand, NEXPTIME-hardness already holds for
coverability, in fixed dimension, for bounded stack, and even if all numbers
are specified in unary
Checking Refinement of Asynchronous Programs against Context-Free Specifications
In the language-theoretic approach to refinement verification, we check that
the language of traces of an implementation all belong to the language of a
specification. We consider the refinement verification problem for asynchronous
programs against specifications given by a Dyck language. We show that this
problem is EXPSPACE-complete -- the same complexity as that of language
emptiness and for refinement verification against a regular specification. Our
algorithm uses several technical ingredients. First, we show that checking if
the coverability language of a succinctly described vector addition system with
states (VASS) is contained in a Dyck language is EXPSPACE-complete. Second, in
the more technical part of the proof, we define an ordering on words and show a
downward closure construction that allows replacing the (context-free) language
of each task in an asynchronous program by a regular language. Unlike downward
closure operations usually considered in infinite-state verification, our
ordering is not a well-quasi-ordering, and we have to construct the regular
language ab initio. Once the tasks can be replaced, we show a reduction to an
appropriate VASS and use our first ingredient. In addition to the inherent
theoretical interest, refinement verification with Dyck specifications captures
common practical resource usage patterns based on reference counting, for which
few algorithmic techniques were known.Comment: Full version of paper accepted for ICALP 202
Checking Refinement of Asynchronous Programs Against Context-Free Specifications
In the language-theoretic approach to refinement verification, we check that the language of traces of an implementation all belong to the language of a specification. We consider the refinement verification problem for asynchronous programs against specifications given by a Dyck language. We show that this problem is EXPSPACE-complete - the same complexity as that of language emptiness and for refinement verification against a regular specification. Our algorithm uses several technical ingredients. First, we show that checking if the coverability language of a succinctly described vector addition system with states (VASS) is contained in a Dyck language is EXPSPACE-complete. Second, in the more technical part of the proof, we define an ordering on words and show a downward closure construction that allows replacing the (context-free) language of each task in an asynchronous program by a regular language. Unlike downward closure operations usually considered in infinite-state verification, our ordering is not a well-quasi-ordering, and we have to construct the regular language ab initio. Once the tasks can be replaced, we show a reduction to an appropriate VASS and use our first ingredient. In addition to the inherent theoretical interest, refinement verification with Dyck specifications captures common practical resource usage patterns based on reference counting, for which few algorithmic techniques were known